C:/Projekte/RAIS/ApplicationLogiLayer/ReportManagement.cs

Go to the documentation of this file.


using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.IO;
using System.Text;
using System.Xml;
using Microsoft.Reporting.WebForms;
using System.Configuration;
using System.Globalization;

using RAIS.Common.DynamicMaskManagement;
using RAIS.Common.UserManagement;
using RAIS.DataAccessLayer;
using RAIS.Common;
using RAIS.Common.RADEVClasses;

namespace RAIS.ApplicationLogicLayer
{
        public static class ReportManagement
        {
                enum ReportPart
                { 
                        Header,
                        Details,
                        Footer,
                        GroupHeader,
                        GroupFooter
                }
                //*********************************************************************
                #region Fields
                const string dataSourceName = "ReportDataSource";
                const string dataSetName = "Report_Table";
                const string rdlcFileName = "Reports/Template - RAIS standard.rdlc"; // - Test.rdlc"; //
                const string logoImageFileName = "Images/iaea.jpg";
                const string rdlcNamespaceURI = "http://schemas.microsoft.com/sqlserver/reporting/2005/01/reportdefinition";
                const string rdNamespaceURI = "http://schemas.microsoft.com/SQLServer/reporting/reportdesigner";
                const string cellXml =
                          "<TableCell xmlns=\"http://schemas.microsoft.com/sqlserver/reporting/2005/01/reportdefinition\" xmlns:rd=\"http://schemas.microsoft.com/SQLServer/reporting/reportdesigner\">"
                        + "     <ReportItems>"
                        + "             <Textbox Name=\"\">"
                        + "                     <rd:DefaultName></rd:DefaultName>"
                        + "                     <Style>"
                        + "                             <PaddingLeft>2pt</PaddingLeft>"
                        + "                             <PaddingRight>2pt</PaddingRight>"
                        + "                             <PaddingTop>2pt</PaddingTop>"
                        + "                             <PaddingBottom>2pt</PaddingBottom>"
                        + "                     </Style>"
                        + "                     <ZIndex>0</ZIndex>"
                        + "                     <CanGrow>true</CanGrow>"
                        + "                     <Value />"
                        + "             </Textbox>"
                        + "     </ReportItems>"
                        + "</TableCell>";

                const string sizeUnitDecmalSeparator = ".";
                const string sizeUnit = "cm";
                const string fontSizeUnit = "pt";
                const string bodyFontSize = "9pt";
                const string bodyFontFamily = "Arial";
                const string groupsFontFamily = "Times New Roman";

                const double sheetLongSideLength = 29.7;
                const double sheetShortSideLength = 21;
                const double interactiveHeight = 4;
                const double leftMargin = 1;
                const double rightMargin = 1;
                const double tableTop = 0;
                const double tableHeight = 4.44444;
                const double rowHeight = 0.63492;
                const double firstColumnWidth = 0.5;
                const int groupFontSize = 11;

                static string rdlcFullName;
                static XmlNamespaceManager namespaceManager;
                static DataSet dataSet;
                static XmlElement root;
                static Dictionary<int, string> groupColumns;
                static Dictionary<int, double> columnsWidths;
                static double pageHeight;
                static double pageWidth;
                static double reportWidth;
                static string reportName;
                static UserData currentUser;
                static string grouping;
                static string widths;
        static string dateRange=null;
                static string logoImageUrl;
                static string additionalFooterText;
        static bool _isRTL;
                #endregion Fields
                //*********************************************************************
                #region Properties              



        public static string DataSetName
                {
                        get { return dataSetName; }
                }
                #endregion Properties
                //*********************************************************************
                #region Public methods








        static public MemoryStream CreateReportDefinition(DynamicMaskData dynamicMaskData
                        , string sitePath, string siteURL, string orientation, string cultureName, bool isRTL)
                {
            _isRTL = isRTL;
                        MemoryStream reportDefinitionStream = new MemoryStream();

                        logoImageUrl = siteURL + logoImageFileName;
            SetDateRange(dynamicMaskData);
                        dataSet = dynamicMaskData.DataSet;
                        currentUser = dynamicMaskData.CurrentUser;
                        reportName = dynamicMaskData.DynamicMask.Name;
                        grouping = dynamicMaskData.DynamicMask.Grouping;
                        widths = dynamicMaskData.DynamicMask.Widths;
                        additionalFooterText = dynamicMaskData.DynamicMask.Footer;


            // Remove _ID fields from dataset
            foreach (DataTable table in dataSet.Tables)
            {
                for (int i = 0; i < table.Columns.Count; i++)
                {
                    if ((table.Columns[i].ColumnName.Contains("PK ") && table.Columns[i].ColumnName.Contains(" ID")) ||
                        (table.Columns[i].ColumnName.Contains("FK ") && table.Columns[i].ColumnName.Contains(" ID")))
                    {
                        table.Columns.Remove(table.Columns[i]);
                        i--;
                    }
                }
            } // End Remove _ID fields from dataset

            

                        if (orientation == "Portrait")
                        {
                                pageHeight = sheetLongSideLength;
                                pageWidth = sheetShortSideLength;
                        }
                        else
                        {
                                pageHeight = sheetShortSideLength;
                                pageWidth = sheetLongSideLength;
                        }
                        reportWidth = pageWidth - leftMargin - rightMargin;

                        // Parse groping string into grouping columns Dictionary
                        ParseGrouppingString();

                        // Parse widths string into columnsWidths Dictionary
                        ParseWidthsString();

                        // Load xml report definition
                        XmlDocument xmlReportDefinition = new XmlDocument();
                        rdlcFullName = string.Format("{0}/{1}", sitePath, rdlcFileName);
                        xmlReportDefinition.Load(rdlcFullName);
                        root = xmlReportDefinition.DocumentElement;

                        // Create namespace manager
                        namespaceManager = new XmlNamespaceManager(xmlReportDefinition.NameTable);
                        namespaceManager.AddNamespace("rdlc", rdlcNamespaceURI);
                        namespaceManager.AddNamespace("rd", rdNamespaceURI);

                        //-- Xml processing
                        // Set language
                        string languageNodePath = "//rdlc:Language";
                        XmlNode languageNode = root.SelectSingleNode(languageNodePath, namespaceManager);
                        if (languageNode != null)
                languageNode.InnerText = cultureName;//System.Globalization.CultureInfo.CurrentCulture.Name;
            
                        // Page settings
                        SetPageSettings();

                        // Set Page header settings
                        SetPageHeaderSettings();

                        // Create DataSources
                        AddDataSourcesNode();

                        // Create DataSets
                        AdddataSetsNode();

                        // Change Body definition
                        XmlElement tableElement = CreateBodyDefinition();

                        // Add Table groups
                        if (groupColumns.Count != 0)
                                AddTableGroups(tableElement);

                        // Create Header Cells
                        AddReportPart(tableElement, ReportPart.Header, 0, 0);

                        // Create Details Cells
                        AddReportPart(tableElement, ReportPart.Details, 0, 0);

                        // Create Footer Cells
                        AddReportPart(tableElement, ReportPart.Footer, 0, 0);

                        // Page Footer elements
                        SetPageFooterControlsSettings();

                        // Save to stream
                        xmlReportDefinition.Save(reportDefinitionStream);
                        reportDefinitionStream.Position = 0;

                        return reportDefinitionStream;
                }
        static public Microsoft.Reporting.WebForms.ReportDataSource GetRADEVDataSource(string provaderName, string reportName, RADEVCriterias criterias)
        {
            Common.RADEVClasses.RADEVTable tab = Common.RADEVClasses.RADEVTable.CreateTable(provaderName, reportName);
            return new Microsoft.Reporting.WebForms.ReportDataSource(tab.GetSourceName(), tab.GetDataList(criterias));
        }
        static public List<RADEVTable> GetRADEVLineList(string provaderName,RADEVCriterias criterias)
        {
            Common.RADEVClasses.RADEVTable tab = Common.RADEVClasses.RADEVTable.CreateTable(provaderName, "EventMaster");
            return (List<RADEVTable>)tab.GetDataList(criterias);
        }
        static public MemoryStream GetTranslatedReportDefinition(UserData user, string rdlcFileName, string siteUrl, string cultureName, bool isRTL)
                {
            _isRTL = isRTL;
                        currentUser = user;
                        MemoryStream reportDefinitionStream = new MemoryStream();

                        // Load xml report definition
                        XmlDocument xmlReportDefinition = new XmlDocument();
                        xmlReportDefinition.Load(rdlcFileName);
                        root = xmlReportDefinition.DocumentElement;

                        // Create namespace manager
                        namespaceManager = new XmlNamespaceManager(xmlReportDefinition.NameTable);
                        namespaceManager.AddNamespace("rdlc", rdlcNamespaceURI);
                        namespaceManager.AddNamespace("rd", rdNamespaceURI);

            string headerImageValueNodePath = "//rdlc:PageHeader/rdlc:ReportItems/rdlc:Image/rdlc:Value";
            XmlNode headerImageValueNode = root.SelectSingleNode(headerImageValueNodePath, namespaceManager);
            if (headerImageValueNode != null)
            {
                headerImageValueNode.InnerText = string.Format("=\"{0}\"", siteUrl + "Images/RADEV_header_logo_new.jpg");
            }

            headerImageValueNodePath = "//rdlc:PageFooter/rdlc:ReportItems/rdlc:Image/rdlc:Value";
            headerImageValueNode = root.SelectSingleNode(headerImageValueNodePath, namespaceManager);
            if (headerImageValueNode != null)
            {
                headerImageValueNode.InnerText = string.Format("=\"{0}\"", siteUrl+"/Images/RADEV_footer_logo_new.jpg");
            }

                        //-- Xml processing
                        // Set language
                        string languageNodePath = "//rdlc:Language";
                        XmlNode languageNode = root.SelectSingleNode(languageNodePath, namespaceManager);
                        if (languageNode != null)
                languageNode.InnerText = cultureName;

                        XmlNode nodeForTranslation;
                        nodeForTranslation = root.SelectSingleNode("//rdlc:PageHeader", namespaceManager);
                        if (nodeForTranslation != null)
                                TranslateTextBoxes(nodeForTranslation);

                        nodeForTranslation = root.SelectSingleNode("//rdlc:Body", namespaceManager);
                        if (nodeForTranslation != null)
                                TranslateTextBoxes(nodeForTranslation);

                        nodeForTranslation = root.SelectSingleNode("//rdlc:PageFooter", namespaceManager);
                        if (nodeForTranslation != null)
                                TranslateTextBoxes(nodeForTranslation);

            AddDirrectionNode(root.SelectSingleNode("//rdlc:Body/rdlc:ReportItems/rdlc:List", namespaceManager));

            if(_isRTL)
                ReversTextBoxs(xmlReportDefinition, namespaceManager);

                        // Save to stream
                        xmlReportDefinition.Save(reportDefinitionStream);
                        reportDefinitionStream.Position = 0;

                        return reportDefinitionStream;
                }
                #endregion Public methods
                //*********************************************************************
                #region Private methods

                static void ParseGrouppingString()
                {
                        if (groupColumns == null)
                                groupColumns = new Dictionary<int, string>();
                        else
                                groupColumns.Clear();

                        string[] groups = grouping.Split(new char[] { ';' });
                        foreach (string groupIndex in groups)
                        {
                                int colNumber;
                                bool success = int.TryParse(groupIndex, out colNumber);
                                if (success && colNumber >= 0 && colNumber < dataSet.Tables[0].Columns.Count)
                                        groupColumns.Add(colNumber, dataSet.Tables[0].Columns[colNumber].ColumnName);
                        }
                }

                static void ParseWidthsString()
                {
                        if (columnsWidths == null)
                                columnsWidths = new Dictionary<int, double>();
                        else
                                columnsWidths.Clear();

                        // Fill columnWidths dictionary from widths string
                        string[] widthsArray = widths.Split(new char[] { ';' });
                        int i = 0;
                        foreach (string columnWidth in widthsArray)
                        {
                                //double width = 0;
                                //bool success = StringToDouble(columnWidth, out width);
                                double widthInPercent = 0;
                                double widthInReportUnits = 0;
                                bool success = StringToDouble(columnWidth, out widthInPercent);
                                widthInReportUnits = 
                                        (groupColumns.Count == 0 ? reportWidth : reportWidth - firstColumnWidth) 
                                        * widthInPercent / 100;
                                if (success && !groupColumns.ContainsKey(i))
                                        //columnsWidths.Add(i, width);
                                        columnsWidths.Add(i, widthInReportUnits);
                                else
                                        columnsWidths.Add(i, 0);
                                i++;
                        }

                        // Add items to dictionary for omited columns
                        if (dataSet.Tables[0].Columns.Count > columnsWidths.Count)
                        { 
                                for (int n = columnsWidths.Count; n < dataSet.Tables[0].Columns.Count; n++)
                                        columnsWidths.Add(n, 0);
                        }

                        // Calculate missed columns width
                        double predefinedColumsWidth = 0;
                        int notPredefinedColumnsNumber = 0;
                        foreach (KeyValuePair<int, double> kvp in columnsWidths)
                        {
                                predefinedColumsWidth += kvp.Value;
                                if (kvp.Value == 0 && !groupColumns.ContainsKey(kvp.Key))
                                        notPredefinedColumnsNumber++;
                        }

                        if (predefinedColumsWidth < reportWidth)
                        { 
                                double missedColumnWidth = 
                                        (reportWidth - predefinedColumsWidth - ((groupColumns.Count != 0) ? firstColumnWidth : 0)) / notPredefinedColumnsNumber;

                                for (int n = 0; n < columnsWidths.Count; n++ )
                                {
                                        if (columnsWidths[n] == 0 && !groupColumns.ContainsKey(n))
                                                columnsWidths[n] = missedColumnWidth;
                                }
                        }
                        else
                        {
                                double columnWidth =
                                        (reportWidth - ((groupColumns.Count != 0) ? firstColumnWidth : 0)) / (dataSet.Tables[0].Columns.Count - groupColumns.Count);

                                for (int n = 0; n < columnsWidths.Count; n++)
                                {
                                        columnsWidths[n] = columnWidth;
                                }
                        }
                }

                static void SetPageSettings()
                {
                        string interactiveHeightNodePath = "//rdlc:InteractiveHeight";
                        XmlNode interactiveHeightNode = root.SelectSingleNode(interactiveHeightNodePath, namespaceManager);
                        if (interactiveHeightNode != null)
                                interactiveHeightNode.InnerText = ReportSize(interactiveHeight);

                        string pageHeightNodePath = "//rdlc:PageHeight";
                        XmlNode pageHeightNode = root.SelectSingleNode(pageHeightNodePath, namespaceManager);
                        if (pageHeightNode != null)
                                pageHeightNode.InnerText = ReportSize(pageHeight);

                        string interactiveWidthNodePath = "//rdlc:InteractiveWidth";
                        XmlNode interactiveWidthNode = root.SelectSingleNode(interactiveWidthNodePath, namespaceManager);
                        if (interactiveWidthNode != null)
                                interactiveWidthNode.InnerText = ReportSize(pageWidth);

                        string pageWidthNodePath = "//rdlc:PageWidth";
                        XmlNode pageWidthNode = root.SelectSingleNode(pageWidthNodePath, namespaceManager);
                        if (pageWidthNode != null)
                                pageWidthNode.InnerText = ReportSize(pageWidth);

                        string widthNodePath = "//rdlc:Width";
                        XmlNode widthNode = root.SelectSingleNode(widthNodePath, namespaceManager);
                        if (widthNode != null)
                                widthNode.InnerText = ReportSize(reportWidth);

                }

        static void SetDateRange()
        {
            if (dateRange == null) return;
            string textBoxNodeString =
            "<Textbox Name=\"DateRange\">" +
            "    <Top>3.25cm</Top>" +
            "    <Width>19cm</Width>" +
            "    <Style>" +
            "       <Color>White</Color>" +
            "       <BackgroundColor>LightGrey</BackgroundColor>" +
            "       <FontFamily>Times New Roman</FontFamily> " +
            "       <PaddingLeft>2pt</PaddingLeft>" +
            "       <PaddingRight>2pt</PaddingRight>" +
            "       <PaddingTop>2pt</PaddingTop>" +
            "       <PaddingBottom>2pt</PaddingBottom>" +
            "       <TextAlign>Left</TextAlign>" +
            "    </Style>" +
            "    <ZIndex>1</ZIndex>" +
            "    <CanGrow>true</CanGrow>" +
            "    <Left>0.25cm</Left>" +
            "    <Value>Text</Value>" +
            "    <Height>0.5cm</Height>" +
            "</Textbox>";

            string reportNameNodePath = "//rdlc:PageHeader/rdlc:ReportItems";
            XmlNode reportItemsNode = root.SelectSingleNode(reportNameNodePath, namespaceManager);
            reportItemsNode.InnerXml = reportItemsNode.InnerXml + textBoxNodeString;
            string valuePath = "//rdlc:PageHeader/rdlc:ReportItems/rdlc:Textbox[@Name='DateRange']/rdlc:Value";
            root.SelectSingleNode(valuePath, namespaceManager).InnerText = dateRange;
        }

        static void SetDateRange(DynamicMaskData dynamicMaskData)
        {
            dateRange = null;
            foreach (DynamicMaskFilterData filter in dynamicMaskData.FiltersData.Values)
                if (filter.DynamicMaskFilter.Type == DynamicMaskFilter.FilterType.DatesRage)
                    dateRange = string.Format("Period: {0} until {1}", filter.DateFrom.ToString("dd.MM.yyyy"), filter.DateUntil.ToString("dd.MM.yyyy"));
        }

                static void SetPageHeaderSettings()
                {
                        // Set Report name
            string reportNameNodePath = "//rdlc:PageHeader/rdlc:ReportItems/rdlc:Textbox[@Name='TXTreporttitle']/rdlc:Value";
                        XmlNode reportNameNode = root.SelectSingleNode(reportNameNodePath, namespaceManager);
                        if (reportNameNode != null)
                        {
                                reportNameNode.InnerText = ReportingTranslation(reportName);
                        }

                        // Set path of header image
                        string headerImageValueNodePath = "//rdlc:PageHeader/rdlc:ReportItems/rdlc:Image/rdlc:Value";
                        XmlNode headerImageValueNode = root.SelectSingleNode(headerImageValueNodePath, namespaceManager);
                        if (headerImageValueNode != null)
                        {
                                headerImageValueNode.InnerText = string.Format("=\"{0}\"", logoImageUrl);
                        }

                        // Set Left position of header image
                        string headerImageWidthNodePath = "//rdlc:PageHeader/rdlc:ReportItems/rdlc:Image/rdlc:Width";
                        XmlNode headerImageWidthNode = root.SelectSingleNode(headerImageWidthNodePath, namespaceManager);
                        string headerImageLeftNodePath = "//rdlc:PageHeader/rdlc:ReportItems/rdlc:Image/rdlc:Left";
                        XmlNode headerImageLeftNode = root.SelectSingleNode(headerImageLeftNodePath, namespaceManager);
                        if (headerImageWidthNode != null
                                && headerImageLeftNode != null)
                        {
                                double imageWidth = 0;
                                bool success = ReportUnitToDouble(headerImageWidthNode.InnerText, out imageWidth);
                                if (success)
                                {
                                        double left = (reportWidth - imageWidth) / 2;
                                        headerImageLeftNode.InnerText = ReportSize(left);
                                }
                        }
            SetDateRange();
                }

                static void AddDataSourcesNode()
                {
                        string dataSourcesNodePath = "//rdlc:DataSources";
                        XmlNode dataSourcesNode = root.SelectSingleNode(dataSourcesNodePath, namespaceManager);
                        if (dataSourcesNode != null)
                        {
                                root.RemoveChild(dataSourcesNode);
                        }
                        XmlElement dataSourcesElement = root.OwnerDocument.CreateElement("DataSources", rdlcNamespaceURI);
                        root.AppendChild(dataSourcesElement);

                        XmlElement dataSourceElement = root.OwnerDocument.CreateElement("DataSource", rdlcNamespaceURI);
                        dataSourceElement.SetAttribute("Name", dataSourceName);
                        dataSourcesElement.AppendChild(dataSourceElement);

                        XmlElement connectionPropertiesElement = root.OwnerDocument.CreateElement("ConnectionProperties", rdlcNamespaceURI);
                        dataSourceElement.AppendChild(connectionPropertiesElement);

                        XmlElement dataProviderElement = root.OwnerDocument.CreateElement("DataProvider", rdlcNamespaceURI);
                        dataProviderElement.InnerText = "SQL";
                        connectionPropertiesElement.AppendChild(dataProviderElement);

                        XmlElement connectStringElement = root.OwnerDocument.CreateElement("ConnectString", rdlcNamespaceURI);
                        connectionPropertiesElement.AppendChild(connectStringElement);
                }

                static void AdddataSetsNode()
                { 
                        string dataSetsNodePath = "//rdlc:DataSets";
                        XmlNode dataSetsNode = root.SelectSingleNode(dataSetsNodePath, namespaceManager);
                        if (dataSetsNode != null)
                        {
                                root.RemoveChild(dataSetsNode);
                        }
                        XmlElement dataSetsElement = root.OwnerDocument.CreateElement("DataSets", rdlcNamespaceURI);
                        root.AppendChild(dataSetsElement);

                        XmlElement dataSetElement = root.OwnerDocument.CreateElement("DataSet", rdlcNamespaceURI);
                        dataSetElement.SetAttribute("Name", dataSetName);
                        dataSetsElement.AppendChild(dataSetElement);

                        XmlElement fieldsElement = root.OwnerDocument.CreateElement("Fields", rdlcNamespaceURI);
                        dataSetElement.AppendChild(fieldsElement);

                        for (int i = 0; i < dataSet.Tables[0].Columns.Count; i++)
                        {
                                XmlElement fieldElement = root.OwnerDocument.CreateElement("Field", rdlcNamespaceURI);
                                fieldElement.SetAttribute("Name", ReportColumnName(dataSet.Tables[0].Columns[i].ColumnName));
                                fieldsElement.AppendChild(fieldElement);

                                XmlElement dataFieldElement = root.OwnerDocument.CreateElement("DataField", rdlcNamespaceURI);
                                dataFieldElement.InnerText = dataSet.Tables[0].Columns[i].ColumnName;
                                fieldElement.AppendChild(dataFieldElement);

                                XmlElement typeNameElement = root.OwnerDocument.CreateElement("TypeName", rdNamespaceURI);
                                typeNameElement.InnerText = "System.String"; //dataSet.Tables[0].Columns[i].DataType.FullName; //
                                fieldElement.AppendChild(typeNameElement);
                        }

                        XmlElement queryElement = root.OwnerDocument.CreateElement("Query", rdlcNamespaceURI);
                        dataSetElement.AppendChild(queryElement);

                        XmlElement dataSourceNameElement = root.OwnerDocument.CreateElement("DataSourceName", rdlcNamespaceURI);
                        dataSourceNameElement.InnerText = dataSourceName;
                        queryElement.AppendChild(dataSourceNameElement);

                        XmlElement commandTextElement = root.OwnerDocument.CreateElement("CommandText", rdlcNamespaceURI);
                        queryElement.AppendChild(commandTextElement);

                        XmlElement useGenericDesignerElement = root.OwnerDocument.CreateElement("UseGenericDesigner", rdNamespaceURI);
                        useGenericDesignerElement.InnerText = "true";
                        queryElement.AppendChild(useGenericDesignerElement);
                }

                static XmlElement CreateBodyDefinition()
                {
                        string bodyNodePath = "//rdlc:Body";
                        XmlNode bodyNode = root.SelectSingleNode(bodyNodePath, namespaceManager);


                        // Create ReportItems element (delete existing before creation)
                        string reportItemsNodePath = "//rdlc:Body/rdlc:ReportItems";
                        XmlNode reportItemsNode = root.SelectSingleNode(reportItemsNodePath, namespaceManager);
                        if (reportItemsNode != null)
                        {
                                bodyNode.RemoveChild(reportItemsNode);
                        }
                        XmlElement reportItemsElement = bodyNode.OwnerDocument.CreateElement("ReportItems", rdlcNamespaceURI);
                        bodyNode.AppendChild(reportItemsElement);

                        // Add Table element
                        XmlElement tableElement = bodyNode.OwnerDocument.CreateElement("Table", rdlcNamespaceURI);
                        tableElement.SetAttribute("Name", "table1");
                        reportItemsElement.AppendChild(tableElement);

                        XmlElement tableDataSetNameElement = bodyNode.OwnerDocument.CreateElement("DataSetName", rdlcNamespaceURI);
                        tableDataSetNameElement.InnerText = dataSetName;
                        tableElement.AppendChild(tableDataSetNameElement);

                        XmlElement tableTopElement = bodyNode.OwnerDocument.CreateElement("Top", rdlcNamespaceURI);
                        tableTopElement.InnerText = ReportSize(tableTop);
                        tableElement.AppendChild(tableTopElement);

                        XmlElement tableHeightElement = bodyNode.OwnerDocument.CreateElement("Height", rdlcNamespaceURI);
                        tableHeightElement.InnerText = ReportSize(tableHeight);
                        tableElement.AppendChild(tableHeightElement);

                        XmlElement tableWidthElement = bodyNode.OwnerDocument.CreateElement("Width", rdlcNamespaceURI);
                        tableWidthElement.InnerText = ReportSize(reportWidth);
                        tableElement.AppendChild(tableWidthElement);

                        // Add Table Columns
                        XmlElement tableColumnsElement = tableElement.OwnerDocument.CreateElement("TableColumns", rdlcNamespaceURI);
                        tableElement.AppendChild(tableColumnsElement);

                        if (groupColumns.Count != 0)
                        {
                                XmlElement tableColumnElement = tableElement.OwnerDocument.CreateElement("TableColumn", rdlcNamespaceURI);
                                tableColumnsElement.AppendChild(tableColumnElement);
                                XmlElement tableColumnWidthElement = tableElement.OwnerDocument.CreateElement("Width", rdlcNamespaceURI);
                                tableColumnWidthElement.InnerText = ReportSize(firstColumnWidth);
                                tableColumnElement.AppendChild(tableColumnWidthElement);
                        }

                        for (int i = 0; i < dataSet.Tables[0].Columns.Count; i++)
                        {
                                if (!groupColumns.ContainsKey(i))
                                {
                                        XmlElement tableColumnElement = tableElement.OwnerDocument.CreateElement("TableColumn", rdlcNamespaceURI);
                                        tableColumnsElement.AppendChild(tableColumnElement);
                                        XmlElement tableColumnWidthElement = tableElement.OwnerDocument.CreateElement("Width", rdlcNamespaceURI);
                                        tableColumnWidthElement.InnerText = ReportSize(columnsWidths[i]);
                                        tableColumnElement.AppendChild(tableColumnWidthElement);
                                }
                        }
                        return tableElement;
                }

                static void AddTableGroups(XmlElement parentElement)
                {
                        XmlElement tableGroupsElement = parentElement.OwnerDocument.CreateElement("TableGroups", rdlcNamespaceURI);
                        parentElement.AppendChild(tableGroupsElement);

                        int i = 0;
                        foreach (KeyValuePair<int, string> kvp in groupColumns)
                        {
                                int columnNumber = kvp.Key;
                                int groupLevel = groupColumns.Count - 1 - i;
                                string fullColumnName = kvp.Value;
                                string columnName = ReportColumnName(fullColumnName);

                                XmlElement tableGroupElement = parentElement.OwnerDocument.CreateElement("TableGroup", rdlcNamespaceURI);
                                tableGroupsElement.AppendChild(tableGroupElement);

                                XmlElement groupingElement = parentElement.OwnerDocument.CreateElement("Grouping", rdlcNamespaceURI);
                                groupingElement.SetAttribute("Name", "table1_group" + columnNumber.ToString());
                                tableGroupElement.AppendChild(groupingElement);

                                XmlElement groupExpressionsElement = parentElement.OwnerDocument.CreateElement("GroupExpressions", rdlcNamespaceURI);
                                groupingElement.AppendChild(groupExpressionsElement);

                                XmlElement groupExpressionElement = parentElement.OwnerDocument.CreateElement("GroupExpression", rdlcNamespaceURI);
                groupExpressionElement.InnerText = string.Format("=IIf(IsNothing(Fields!{0}.Value), \"not specified\",Fields!{0}.Value)", columnName);
                                groupExpressionsElement.AppendChild(groupExpressionElement);

                                XmlElement sortingElement = parentElement.OwnerDocument.CreateElement("Sorting", rdlcNamespaceURI);
                                tableGroupElement.AppendChild(sortingElement);

                                XmlElement sortByElement = parentElement.OwnerDocument.CreateElement("SortBy", rdlcNamespaceURI);
                                sortingElement.AppendChild(sortByElement);

                                XmlElement sortExpressionElement = parentElement.OwnerDocument.CreateElement("SortExpression", rdlcNamespaceURI);
                sortExpressionElement.InnerText = string.Format("=IIf(IsNothing(Fields!{0}.Value), \"not specified\",Fields!{0}.Value)", columnName);
                                sortByElement.AppendChild(sortExpressionElement);

                                XmlElement directionElement = parentElement.OwnerDocument.CreateElement("Direction", rdlcNamespaceURI);
                                directionElement.InnerText = "Ascending";
                                sortByElement.AppendChild(directionElement);

                                AddReportPart(tableGroupElement, ReportPart.GroupHeader, columnNumber, groupLevel);
                                //AddReportPart(tableGroupElement, ReportPart.GroupFooter, columnNumber);
                                i++;
                        }
                }

                static void AddReportPart(XmlElement parentElement, ReportPart reportPart, int columnNumber, int groupLevel)
                {
                        string reportPartElementName = string.Empty;
                        switch (reportPart)
                        {
                                case ReportPart.Header:
                                case ReportPart.GroupHeader:
                                        reportPartElementName = "Header";
                                        break;
                                case ReportPart.Details:
                                        reportPartElementName = "Details";
                                        break;
                                case ReportPart.Footer:
                                case ReportPart.GroupFooter:
                                        reportPartElementName = "Footer";
                                        break;
                        }

                        XmlElement reportPartElement = parentElement.OwnerDocument.CreateElement(reportPartElementName, rdlcNamespaceURI);
                        parentElement.AppendChild(reportPartElement);

                        XmlElement tableRowsElement = reportPartElement.OwnerDocument.CreateElement("TableRows", rdlcNamespaceURI);
                        reportPartElement.AppendChild(tableRowsElement);
                        XmlElement tableRowElement = reportPartElement.OwnerDocument.CreateElement("TableRow", rdlcNamespaceURI);
                        tableRowsElement.AppendChild(tableRowElement);
                        XmlElement tableCellsElement = reportPartElement.OwnerDocument.CreateElement("TableCells", rdlcNamespaceURI);
                        tableRowElement.AppendChild(tableCellsElement);

                        if (reportPart == ReportPart.GroupHeader
                                || reportPart == ReportPart.GroupFooter)
                        {
                                AddTableCell(tableCellsElement, groupColumns[columnNumber], reportPart, groupLevel);
                        }
                        else
                        {
                                if (groupColumns.Count != 0)
                                        AddTableCell(tableCellsElement, string.Empty, reportPart, groupLevel);

                int from = _isRTL ? dataSet.Tables[0].Columns.Count - 1 : 0;
                int to = _isRTL ? -1 : dataSet.Tables[0].Columns.Count;
                int increment = _isRTL ? -1 : 1;

                for (int i = from; i != to; i+=increment)
                                {
                                        if (!groupColumns.ContainsKey(i))
                                        {
                                                string columnName = dataSet.Tables[0].Columns[i].ColumnName;
                                                AddTableCell(tableCellsElement, columnName, reportPart, groupLevel);
                                        }
                                }
                        }
                        XmlElement tableRowHeightElement = reportPartElement.OwnerDocument.CreateElement("Height", rdlcNamespaceURI);
                        tableRowHeightElement.InnerText = ReportSize(rowHeight);
                        tableRowElement.AppendChild(tableRowHeightElement);
                }

                static void AddTableCell(XmlElement cellsElement, string fullColumnName, ReportPart reportPart, int groupLevel)
                {
                        string columnName = ReportColumnName(fullColumnName);

                        XmlDocumentFragment cellFragment = cellsElement.OwnerDocument.CreateDocumentFragment();
                        cellFragment.InnerXml = cellXml;
                        XmlNode newNode = cellFragment.SelectSingleNode("//rdlc:TableCell", namespaceManager);

                        if (reportPart == ReportPart.GroupHeader
                                || reportPart == ReportPart.GroupFooter)
                        {
                                XmlElement colspanElement = newNode.OwnerDocument.CreateElement("ColSpan", rdlcNamespaceURI);
                                colspanElement.InnerXml = (dataSet.Tables[0].Columns.Count - groupColumns.Count + 1).ToString();
                                newNode.AppendChild(colspanElement);
                        }

                        XmlNode textbox = newNode.SelectSingleNode("//rdlc:Textbox", namespaceManager);
                        textbox.Attributes["Name"].Value = columnName + reportPart.ToString();

            AddDirrectionNode(textbox);

                        XmlNode defaultName = newNode.SelectSingleNode("//rdlc:Textbox/rd:DefaultName", namespaceManager);
                        defaultName.InnerText = columnName + reportPart.ToString();

                        XmlNode styleElement = newNode.SelectSingleNode("//rdlc:Textbox/rdlc:Style", namespaceManager);
                        if (reportPart == ReportPart.Header)
                        {
                                XmlElement borderStyleElement = cellsElement.OwnerDocument.CreateElement("BorderStyle", rdlcNamespaceURI);
                                styleElement.AppendChild(borderStyleElement);

                                XmlElement bottomElement = cellsElement.OwnerDocument.CreateElement("Bottom", rdlcNamespaceURI);
                                bottomElement.InnerText = "Solid";
                                borderStyleElement.AppendChild(bottomElement);
                        }
                        
                        if (reportPart == ReportPart.GroupHeader)
                        {
                                if (groupLevel == 0 || groupLevel == 3)
                                {
                                        XmlElement colorElement = cellsElement.OwnerDocument.CreateElement("Color", rdlcNamespaceURI);
                                        colorElement.InnerText = "MediumBlue";
                                        styleElement.AppendChild(colorElement);
                                }

                                XmlElement fontFamilyElement = cellsElement.OwnerDocument.CreateElement("FontFamily", rdlcNamespaceURI);
                                fontFamilyElement.InnerText = groupsFontFamily;
                                styleElement.AppendChild(fontFamilyElement);

                                XmlElement fontSizeElement = cellsElement.OwnerDocument.CreateElement("FontSize", rdlcNamespaceURI);
                                int fontSize = groupFontSize + groupLevel;
                                fontSizeElement.InnerText = fontSize.ToString() + fontSizeUnit;
                                styleElement.AppendChild(fontSizeElement);

                                if (groupLevel == 1 || groupLevel == 2)
                                {
                                        XmlElement fontWeightElement = cellsElement.OwnerDocument.CreateElement("FontWeight", rdlcNamespaceURI);
                                        fontWeightElement.InnerText = "Bold";
                                        styleElement.AppendChild(fontWeightElement);
                                }

                                if (groupLevel == 0)
                                {
                                        XmlElement fontStyleElement = cellsElement.OwnerDocument.CreateElement("FontStyle", rdlcNamespaceURI);
                                        fontStyleElement.InnerText = "Italic";
                                        styleElement.AppendChild(fontStyleElement);
                                }

                                if (groupLevel == 1)
                                {
                                        XmlElement textDecorationElement = cellsElement.OwnerDocument.CreateElement("TextDecoration", rdlcNamespaceURI);
                                        textDecorationElement.InnerText = "Underline";
                                        styleElement.AppendChild(textDecorationElement);
                                }
                        }

                        if (reportPart == ReportPart.Details
                                || reportPart == ReportPart.Header)
                        {
                                XmlElement fontFamilyElement = cellsElement.OwnerDocument.CreateElement("FontFamily", rdlcNamespaceURI);
                                fontFamilyElement.InnerText = bodyFontFamily;
                                styleElement.AppendChild(fontFamilyElement);

                                XmlElement fontSizeElement = cellsElement.OwnerDocument.CreateElement("FontSize", rdlcNamespaceURI);
                                fontSizeElement.InnerText = bodyFontSize;
                                styleElement.AppendChild(fontSizeElement);

                XmlElement AlignmentElement = cellsElement.OwnerDocument.CreateElement("TextAlign", rdlcNamespaceURI);
                if (_isRTL)
                    AlignmentElement.InnerText = "Right";
                else
                    AlignmentElement.InnerText = "Left";
                styleElement.AppendChild(AlignmentElement);
                        }

                        XmlNode value = newNode.SelectSingleNode("//rdlc:Textbox/rdlc:Value", namespaceManager);
                        switch (reportPart)
                        {
                                case ReportPart.Header:
                                        value.InnerText = ReportingTranslation(fullColumnName);
                                        break;
                                case ReportPart.Details:
                                case ReportPart.GroupHeader:
                                        if (!string.IsNullOrEmpty(fullColumnName))
                        value.InnerText = string.Format("=IIf(IsNothing(Fields!{0}.Value), \"not specified\",Fields!{0}.Value)", columnName);   
                                        break;
                        }
                        cellsElement.AppendChild(cellFragment);
                }

                static void SetPageFooterControlsSettings()
                {
                        string footerLineWidthNodePath = "//rdlc:PageFooter/rdlc:ReportItems/rdlc:Line/rdlc:Width";
                        XmlNode footerLineWidthNode = root.SelectSingleNode(footerLineWidthNodePath, namespaceManager);
                        if (footerLineWidthNode != null)
                                footerLineWidthNode.InnerText = ReportSize(reportWidth);

                        string footerTextboxNodePath = "//rdlc:PageFooter/rdlc:ReportItems/rdlc:Textbox";
                        XmlNodeList footerTextboxes = root.SelectNodes(footerTextboxNodePath, namespaceManager);
                        foreach (XmlNode footerTextboxNode in footerTextboxes)
                        {
                AddDirrectionNode(footerTextboxNode);
                                if (footerTextboxNode.Attributes["Name"].Value == "TXTadditionalFooterText")
                                {
                                        if (string.IsNullOrEmpty(additionalFooterText))
                                        {
                                                string footerReportItemsNodePath = "//rdlc:PageFooter/rdlc:ReportItems";
                                                XmlNode footerReportItemsNode = root.SelectSingleNode(footerReportItemsNodePath, namespaceManager);
                                                if (footerReportItemsNode != null)
                                                        footerReportItemsNode.RemoveChild(footerTextboxNode);
                                        }
                                        else
                                        {
                                                foreach (XmlNode footerValueNode in footerTextboxNode.ChildNodes)
                                                {
                                                        if (footerValueNode.Name == "Value")
                                                                footerValueNode.InnerText = string.Format(
                                                                        "= \"{0}\""
                                                                        , additionalFooterText);
                                                }
                                        }
                                }

                                if (footerTextboxNode.Attributes["Name"].Value == "TXTprintdate")
                                {
                                        foreach (XmlNode footerValueNode in footerTextboxNode.ChildNodes)
                                        {
                                                if (footerValueNode.Name == "Value")
                                                        footerValueNode.InnerText = string.Format(
                                                                "= \"{0}: \" + CStr(CDate(CStr(Now()))) + \", {1}: {2}\""
                                                                , ReportingTranslation("Print Date")
                                                                , ReportingTranslation("User")
                                                                , currentUser.Name);

                                                if (footerValueNode.Name == "Top"
                                                        && string.IsNullOrEmpty(additionalFooterText))
                                                        footerValueNode.InnerText = "0.25cm";
                                        }
                                }

                                if (footerTextboxNode.Attributes["Name"].Value == "TXTpage")
                                {
                                        int leftNodeIndex = 0;
                                        int i = 0;
                                        double left = 0;
                                        foreach (XmlNode footerValueNode in footerTextboxNode.ChildNodes)
                                        {
                                                if (footerValueNode.Name == "Value")
                                                        footerValueNode.InnerText = "= \"" + string.Format(
                                                                ReportingTranslation("Page {0} of {1}")
                                                                , "\" + CStr(Globals!PageNumber) + \""
                                                                , "\" + CStr(Globals!TotalPages)");

                                                if (footerValueNode.Name == "Width")
                                                {
                                                        double textboxWidth = 0;
                                                        bool success = ReportUnitToDouble(footerValueNode.InnerText, out textboxWidth);
                                                        if (success)
                                                        {
                                                                left = reportWidth - textboxWidth;
                                                        }
                                                }

                                                if (footerValueNode.Name == "Left")
                                                        leftNodeIndex = i;


                                                if (footerValueNode.Name == "Top"
                                                        && string.IsNullOrEmpty(additionalFooterText))
                                                        footerValueNode.InnerText = "0.25cm";

                                                i++;
                                        }

                                        if (left != 0)
                                                footerTextboxNode.ChildNodes[leftNodeIndex].InnerText = ReportSize(left);
                                }
                        }
                }
                #endregion Private methods
                //*********************************************************************
                #region Utils functions

        static void ReversTextBoxs(XmlDocument doc,XmlNamespaceManager namespaceManager)
        {
            CultureInfo ci = new CultureInfo("en-US");
            NumberFormatInfo numberFormatInfo = ci.NumberFormat;
            XmlNodeList list = doc.SelectNodes("//rdlc:Textbox", namespaceManager);
            XmlNode interactiveWidthNode = doc.SelectSingleNode("//rdlc:InteractiveWidth", namespaceManager);
            float interactiveWidth = GetSize(interactiveWidthNode.InnerText, numberFormatInfo);
            foreach (XmlNode textBox in list)
            {
                float width = GetSize(textBox.SelectSingleNode("rdlc:Width", namespaceManager).InnerText, numberFormatInfo);
                XmlNode leftNode = textBox.SelectSingleNode("rdlc:Left", namespaceManager);
                if (leftNode == null)
                    continue;
                float left = GetSize(leftNode.InnerText, numberFormatInfo);

                left = interactiveWidth - left - width;

                left = left > 0 ? left : 0;

                leftNode.InnerText = left.ToString(numberFormatInfo) + "cm";
            }
        }

        static float GetSize(string sizeCm, NumberFormatInfo numberFormatInfo)
        {
            float size;
            size = float.Parse(sizeCm.Substring(0, sizeCm.Length - 2), numberFormatInfo);
            return size;
        }

        static private void AddDirrectionNode(XmlNode node)
        {
            XmlNode directionNode = root.OwnerDocument.CreateElement("rdlc:Direction", rdlcNamespaceURI);
            directionNode.InnerText = _isRTL ? "RTL" : "LTR";
            XmlNode styleNode = node.SelectSingleNode("rdlc:Style", namespaceManager);
            if (styleNode == null)
            {
                styleNode = root.OwnerDocument.CreateElement("rdlc:Style", rdlcNamespaceURI);
                node.AppendChild(styleNode);
            }
            styleNode.AppendChild(directionNode);
        }

                static bool StringToDouble(string stringToParse, out double number)
                {
                        string separator = System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator;

                        stringToParse = stringToParse.Replace(sizeUnitDecmalSeparator, separator);

                        return double.TryParse(stringToParse, out number);
                }

                static string ReportSize(double size)
                {
                        string separator = System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator;
                        return size.ToString().Replace(separator, sizeUnitDecmalSeparator) + sizeUnit;
                }

                static bool ReportUnitToDouble(string reportUnit, out double size)
                {
                        string separator = System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator;

                        reportUnit = reportUnit.Replace(sizeUnit, string.Empty);
                        reportUnit = reportUnit.Replace(sizeUnitDecmalSeparator, separator);

                        return double.TryParse(reportUnit, out size);
                }

                static string ReportColumnName(string fullColumnName)
                {
            return fullColumnName.Replace(" ", string.Empty).Replace("-", string.Empty).Replace("(", string.Empty).Replace(")", string.Empty);
                }

                static string ReportingTranslation(string text)
                {
                        return RAIS.ApplicationLogicLayer.Localisation.Translate(text
                                , RAIS.Common.Messages.REPORTING_CONTEXT
                                , RAIS.Common.Constants.DEFAULT_LANGUAGE
                                , currentUser.Language);
                }

                static void TranslateTextBoxes(XmlNode node)
                {
                        XmlNodeList nodes = node.SelectNodes("*", namespaceManager);
                        foreach (XmlNode childNode in nodes)
                        {
                                if (childNode.Name == "Textbox")
                                {
                                        XmlNode textBoxValueNode = childNode.SelectSingleNode("rdlc:Value", namespaceManager);
                                        if (textBoxValueNode != null && textBoxValueNode.InnerText.Length != 0)
                                        {
                        AddDirrectionNode(childNode);
                                                if (textBoxValueNode.InnerText.Substring(0, 1) != "=")
                                                {
                                                        textBoxValueNode.InnerText =
                                                                ReportingTranslation(textBoxValueNode.InnerText);
                                                }
                                        }
                                }
                                else
                                {
                                        TranslateTextBoxes(childNode);
                                }
                        }
                }
                #endregion Utils functions
        }
}